package com.jiepos.mpos.core.util;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.net.URL;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.web.multipart.MultipartFile;
import org.springframework.web.multipart.MultipartHttpServletRequest;

import com.jiepos.mpos.common.constant.SystemConstant;
/**
 * 
 * <p>标题: —— 文件处理工具类</p>
 * <p>模块: 通用平台</p>
 * <p>版权: Copyright (c) 2017 江苏杰博实信息技术有限公司
 * @author 娄伟峰
 * @version 1.0
 * @since 2017年9月11日 下午2:25:30
 * @history（历次修订内容、修订人、修订时间等）
 */
public class FileUtils {

	/** 日志方法 */
	private static Logger log = LoggerFactory.getLogger(FileUtils.class);
	
	private FileUtils() {
		// null
	}

	/**
	 * 创建目录
	 * @param dir 目录路径
	 *            String 如 c:/fqf
	 */
	public static void makeDirs(String dir) {
		try {
			File file = new File(dir);
			file.mkdirs();
		} catch (Exception e) {
			log.debug("makeDir error : ", e);
		}
	}
	/**
	 * 创建文件
	 * @param filePath
	 */
	public static File makeFile(String filePath) {
		try {
			File file = new File(filePath);
			file.createNewFile();
			return file;
		} catch (Exception e) {
			log.error("makeDir error : ", e);
		}
		return null;
	}
	
	/**
	 * 判断目录是否存在
	 * @param filePath
	 * @return
	 */
	public static boolean checkDirs(String filePath){
		File file = new File(filePath);
		return file.exists();
		
	}
	
	/**
	 * 获取当前文件的文件名
	 * 如：c:/user/log.txt  ->  log.txt
	 * @param file 文件实际路径
	 * @return
	 */
	public static String getFileName(String file) {
		if (file == null) {
			return file;
		}
		return file.replaceAll("^.+[/\\\\]", "");
	}
	
	/**
	 * 获取当前文件的目录
	 * 如果当前文件是目录，则返回其父目录
	 * @param file 文件实际路径
	 */
	public static String getFileDir(String file) {
		if (file == null) {
			return file;
		}
		return file.replaceAll("[/\\\\][^/\\\\]+$", "");
	}

	/**
	 * 得到文件的URL连接 ;
	 * 
	 * @param 文件名
	 * @return URL 文件路径
	 */
	public static URL getFileURL(String fileName) {
		ClassLoader loader = FileUtils.class.getClassLoader();
		URL fileUrl = loader.getResource(fileName);
		return fileUrl;
	}

	/**
	 * 判断文件是否适合复制操作
	 * 
	 * @param filefrom
	 * @param fileto
	 * @return boolean
	 */
	public static boolean checkFile(java.io.File filefrom, java.io.File fileto) {
		// 文件不存在
		if (!filefrom.exists()) {
			log.debug("文件不存在");
			return false;}
		// 不能够复制文件夹
		if (!filefrom.isFile()) {
			log.debug("不能够复制文件夹");
			return false;
		}
		// 不能够读取需要复制的文件
		if (!filefrom.canRead()) {
			log.debug("不能够读取需要复制的文件");
			return false;
		}
		// 返回此抽象路径名的父路径名的抽象路径名，如果此路径名没有指定父目录，则返回 null。
		if (!fileto.getParentFile().exists()) {
			fileto.getParentFile().mkdirs();
			log.debug("返回此抽象路径名的父路径名的抽象路径名的指定父目录为NULL");
			return false;
		}
		// 测试此抽象路径名表示的文件或目录是否存在
		if (fileto.exists()) {
			log.debug("测试此抽象路径名表示的文件或目录是否存在");
			fileto.delete();
			return false;
		}
		return true;
	}

	 
	/**
	 * 获取文件目录下面所有的文件，包括子目录下面的文件
	 * 
	 * @param filePath
	 *            文件路径
	 * @return String 所有的文件名，中间以;号隔开
	 */
	public static List getFileFoder(String filePath, List filelist) {
		File input = new File(filePath);
		File println = input.getAbsoluteFile();// 取的是子目录
		String fileName = "";
		if (println.isDirectory()) {
			String xx = "";
			String[] list = println.list();
			for (int i = 0; i < list.length; i++) {
				String str = list[i];
				Map map = new HashMap();
				fileName = fileName + ";" + str;
				map.put("fileName", fileName);
				if (!str.endsWith(".zip")) {
					xx = filePath + File.separator + list[i];
					map.put("filePath", xx);
					getFileFoder(xx, filelist);
				} else {
					map.put("filePath", filePath + File.separator + list[i]);
				}
				filelist.add(map);
			}
		}
		return filelist;
	}

	    
	/**
	 * 检查是否是个合法的文件
	 * @param file
	 */
	private static boolean checkFile(File file) {
		boolean isOK = true;
		try {
			String name = "\"" + file.getCanonicalPath() + "\"";
			if (!file.exists()) {
				log.info(name + " is not exist.");
			} else if (file.isDirectory()) {
				log.info(name + "\" is not a file.");
			}
		} catch (IOException e) {
			log.error("check file error.", e);
		}
		
		return isOK;
	}
	
	/**
	 * 检查是否是个合法的目录
	 * @param dir
	 */
	private static boolean checkDir(File dir) {
		boolean isOK = true;
		try {
			String name = "\"" + dir.getCanonicalPath() + "\"";
			if (!dir.exists()) {
				log.info(name + " is not exist.");
			} else if (!dir.isDirectory()) {
				log.info(name + "\" is not a directory.");
			}
		} catch (IOException e) {
			log.error("check dir error.", e);
		}
		
		return isOK;
	}
	
	/**
	 * 读取文件内容
	 * @param file 文件标准路径
	 * @return 文件内容
	 */
	public static String read(String file) {
		File f = new File(file);
		if (!f.exists()) {
			return "";
		}
		StringBuilder sb = new StringBuilder();
		BufferedReader br = null;
		try {
//			br = new BufferedReader(new FileReader(file));
			br = new BufferedReader(new InputStreamReader(
					new FileInputStream(file), "utf-8"));
			char[] buf = new char[2000];
			int len = 0;
			while ((len = br.read(buf)) != -1) {
				sb.append(buf, 0, len);
			}
		} catch (Exception e) {
			log.error("read file error.", e);
		} finally {
			if (br != null) {
				try {
					br.close();
				} catch (IOException e) {
					log.error("close file error.");
				}
			}
		}
		return sb.toString();
	}
	
	/**
	 * 读取文件内容
	 * @param file 文件标准路径
	 * @param content 我内容
	 * @return 文件内容
	 */
	public static void write(String file, String content) {
		BufferedWriter bw = null;
		try {
//			bw = new BufferedWriter(new FileWriter(file));
			bw = new BufferedWriter(new OutputStreamWriter(
					new FileOutputStream(file), "utf-8"));
			bw.write(content);
		} catch (Exception e) {
			log.error("writer file error.");
		} finally {
			if (bw != null) {
				try {
					bw.close();
				} catch (IOException e) {
					log.error("close file error.");
				}
			}
		}
	}
	
	/**
	 * 复制文件
	 * @param file 要被复制的文件
	 * @param dir 复制文件后存放的目录
	 * @param newName 新文件名
	 * @param 成功返回 true， 失败返回 false
	 */
	private static boolean copyFile(File file, File dir, String newName) throws IOException {
		boolean isOK = false;
		if (StringUtils.isEmpty(newName)) {
			newName = file.getName();
		} else {
			newName = newName + "." + getSuffix(file.getName());
		}
		BufferedInputStream bis = null;
		BufferedOutputStream bos = null;
		try {
			bis = new BufferedInputStream(new FileInputStream(file));
			if(!newName.equals("Thumbs.db")){
				bos = new BufferedOutputStream(new FileOutputStream(dir.getCanonicalPath() + File.separator + newName));
				byte[] buf = new byte[2000];
				int len = 0;
				while ((len = bis.read(buf)) != -1) {
					bos.write(buf, 0, len);
					bos.flush();
				}
			}
		} catch (Exception e) {
			log.error("copy file error.", e);
		} finally {
			if (bis != null) {
				bis.close();
			}
			if (bos != null) {
				bos.close();
			}
		}
		isOK = true;
		return isOK;
	}
	
	/**
	 * 递归复制
	 * @param fromDir 源目录
	 * @param toDir 目标目录
	 * @return
	 * @throws IOException 
	 */
	private static boolean copyIter(File fromDir, File toDir) throws IOException {
		boolean isOK = false;
		File[] files = fromDir.listFiles();
		if (files != null) {
			File currFile = null;
			for (int i = 0; i < files.length; i++) {
				currFile = files[i];
				if (currFile.isFile()) {
					isOK = copyFile(currFile, toDir, null);
				} else if (currFile.isDirectory()) {
					File newToDir = new File(toDir.getCanonicalPath() + File.separator + currFile.getName());
					newToDir.mkdir();
					isOK = copyIter(currFile, newToDir);
				}
			}
		}
		return isOK;
	}
	
	/**
	 * 将文件复制到目的地
	 * @param fromFile 文件或文件夹
	 * @param toDir 目的目录
	 * @return
	 */
	public static boolean copy(String fromFile, String toDir) {
		return copy(fromFile, toDir, true);
	}
	
	/**
	 * 将文件复制到目的地
	 * @param fromFile 文件或文件夹
	 * @param toDir 目的目录
	 * @param newName 如果是文件，则代表新文件名称，如果是文件夹则无意义
	 * @return
	 */
	public static boolean copy(String fromFile, String toDir, String newName) {
		return copy(fromFile, toDir, newName, true);
	}
	
	/**
	 * 将文件或文件夹复制到目的地
	 * @param fromFile 文件或文件夹
	 * @param toDir 目的目录
	 * @param newName 新的文件或文件夹名称
	 * @param hasSrcDir 是否包含源目录
	 * 	true：如果fromFile是一个文件夹，那么该文件夹及其下所有文件或文件夹均被复制
	 *  false: 如果fromFile是一个文件夹，那么只复制该文件夹下所有文件或文件夹，但不复制当前文件夹
	 * @return
	 */
	public static boolean copy(String fromFile, String toDir, String newName, boolean hasSrcDir) {
		boolean isOK = false;
		File file = new File(fromFile);
		File dir = new File(toDir);
		try {
			if (!file.exists()) {	// 被复制的文件不存在
				log.error("copyed file not exist : " + file.getCanonicalPath());
				return false;
			} else if (!dir.exists()) {	// 目标文件夹不存在
				log.error("target directory not exist : " + dir.getCanonicalPath());
				return false;
			} else if (!dir.isDirectory()) {	// 目标文件不是文件夹
				log.error("target file is not a directory : " + dir.getCanonicalPath());
				return false;
			}
		
			if (file.isDirectory()) {	// 如果是目录
				// 如果包含源目录，则拷贝源目录
				if (hasSrcDir) {
					if (StringUtils.isEmpty(newName)) {
						newName = file.getName();
					}
					dir = new File(toDir + File.separator + newName);
					dir.mkdir();
				} 
				copyIter(file, dir);
			} else {
				isOK = copyFile(file, dir, newName);
			}
		} catch (IOException e) {
			log.error("copy file error : ", e);
		}
		
		return isOK;
	}
	
	/**
	 * 将文件或文件夹复制到目的地
	 * @param fromFile 文件或文件夹
	 * @param toDir 目的目录
	 * @param hasSrcDir 是否包含源目录
	 * 	true：如果fromFile是一个文件夹，那么该文件夹及其下所有文件或文件夹均被复制
	 *  false: 如果fromFile是一个文件夹，那么只复制该文件夹下所有文件或文件夹，但不复制当前文件夹
	 * @return
	 */
	public static boolean copy(String fromFile, String toDir, boolean hasSrcDir) {
		return copy(fromFile, toDir, null, hasSrcDir);
	}
	
	//public static String  


	/**
	 * 判断该路径对应的文件是否存在
	 * 
	 * @param filePath
	 * @return boolean true/false
	 */
	public static boolean isExist(String filePath) {
		File file = new File(filePath);
		return file.exists();
	}

	/**
	 * 删除目录(该文件下的所有文件和目录也被删除)
	 * @return 成功返回 true, 失败返回 false
	 * @throws IOException 
	 */
	private static boolean deleteDir(File dir) throws IOException {
		File[] fileList = dir.listFiles();
		File dirFile = null;

		if (fileList != null) {
			File currFile = null;
			for (int i = 0; i < fileList.length; i++) {
				currFile = fileList[i];
				if (currFile.isFile()) {
					currFile.delete();
				} else if (currFile.isDirectory()) {
					dirFile = currFile.getCanonicalFile();
					// 递归删除指定目录下所有文件
					deleteDir(dirFile);
				}
			}
		}
		return dir.delete();
	}
	
	/**
	 * 判断该路径所表示的文件是否是一个目录
	 * @param file 文件路径 
	 * @return
	 */
	public static boolean isDirectory(String file) {
		return new File(file).isDirectory();
	}
	
	/**
	 * 删除一个文件或文件夹
	 * 如果是文件夹，那么该文件夹下所有文件均被删除
	 * @param file 文件或文件夹路径
	 * @return 成功返回true,失败返回false
	 */
	public static boolean delete(String file) {
		boolean isOK = false;
		File f = new File(file);
		if (!f.exists()) {
			log.debug("deleted file not exist: " + file);
			return false;
		}
		try {
			if (f.isDirectory()) { // 如果是目录
				isOK = deleteDir(f);
			} else {
				isOK = f.delete();
			}
		} catch (IOException e) {
			log.error("delete file error : ", e);
		}
		return isOK;
	}
	
	/**
	 * 判断某个文件是否为图片
	 * 包括：jpg|gif|jpeg|bmp|png
	 * @param fileName 文件名 如： aa.jpg 或 c:/text/aa.jpg
	 * @return boolean
	 */
	public static boolean isPicture(String fileName) {
		String regex = ".*\\.(jpg|gif|jpeg|bmp|png)$";
		Pattern p = Pattern.compile(regex, Pattern.CASE_INSENSITIVE);
		Matcher m = p.matcher(fileName);
		return m.find();
	}
	
	/**
	 * 判断某个文件是否为FALSH
	 * 包括：swf
	 * @param fileName 文件名 如： aa.jpg 或 c:/text/aa.jpg
	 * @return boolean
	 */
	public static boolean isFlash(String fileName) {
		String regex = ".*\\.(swf)$";
		Pattern p = Pattern.compile(regex, Pattern.CASE_INSENSITIVE);
		Matcher m = p.matcher(fileName);
		return m.find();
	}
	
	/**
	 * 判断某个文件是否为网页文件
	 * 包括: html|htm
	 * @param fileName 
	 * @return
	 */
	public static boolean isHtml(String fileName) {
		String regex = ".*\\.(html|htm)$";
		Pattern p = Pattern.compile(regex, Pattern.CASE_INSENSITIVE);
		Matcher m = p.matcher(fileName);
		return m.find();
	}
	
	/**
	 * 判断某个文件是否为JS文件
	 * 包括: .js
	 * @param fileName 
	 * @return
	 */
	public static boolean isJs(String fileName) {
		String regex = ".*\\.(js)$";
		Pattern p = Pattern.compile(regex, Pattern.CASE_INSENSITIVE);
		Matcher m = p.matcher(fileName);
		return m.find();
	}
	
	
	/**
	 * 判断某个文件是否为压缩文件
	 * 包括：rar|zip
	 * @param fileName 文件名 如： aa.zip 或 c:/text/aa.ZIP
	 * @return boolean
	 * @return
	 */
	public static boolean isCompressedFile(String fileName) {
		String regex = ".*\\.(rar|zip)$";
		Pattern p = Pattern.compile(regex, Pattern.CASE_INSENSITIVE);
		Matcher m = p.matcher(fileName);
		return m.find();
	}
	
	/**
	 * 判断某个文件是否为zip包
	 * 包括：zip
	 * @param fileName
	 * @return
	 */
	public static boolean isZip(String fileName) {
		String regex = ".*\\.zip$";
		Pattern p = Pattern.compile(regex, Pattern.CASE_INSENSITIVE);
		Matcher m = p.matcher(fileName);
		return m.find();
	}
	
	/**
	 * 判断文件是否符合指定的文件格式
	 * 如: 想要判断一个文件是否为jpg或gif格式
	 * 调用方式： 
	 * FielUtil.isAppointFormat("aa.txt", "jpg");
	 * @param fileName 文件名
	 * @param suffixes 文件后缀 多个用"|"隔开, 如 "jpg|gif"
	 * @return
	 */
	public static boolean isAppointFormat(String fileName, String suffixes) {
		String regex = ".*\\.(" + suffixes + ")$";
		Pattern p = Pattern.compile(regex, Pattern.CASE_INSENSITIVE);
		Matcher m = p.matcher(fileName);
		return m.find();
	}
	
	/**
	 * 判断附件是否为合法附件
	 * 包括：htm|html|txt|doc|xls|rar|zip|jpg|gif|jpeg|bmp|png|ico|swf
	 * @param fileName 文件名 如：aa.txt 或 c:/text/aa.doc
	 * @return
	 */
	public static boolean isPermitAttachment(String fileName) {
		String regex = ".*\\.(htm|html|txt|doc|xls|rar|zip|jpg|gif|jpeg|bmp|png|ico|swf)$";
		Pattern p = Pattern.compile(regex, Pattern.CASE_INSENSITIVE);
		Matcher m = p.matcher(fileName);
		return m.find();
	}
	
	/**
	 * 获取文件后缀名
	 * @param fileName 文件名称 如：cc.rar
	 * @return
	 */
	public static String getSuffix(String fileName) {
		String regex = "\\.(\\w*)$";
		Pattern p = Pattern.compile(regex, Pattern.CASE_INSENSITIVE);
		Matcher m = p.matcher(fileName);
		m.find();
		return m.group(1);
	}
	
	/**
	 * 获取指定目录下所有的文件路径
	 * @param dir
	 * @param hasDir true:包含目录（文件+目录）     false:不包含目录（仅文件）
	 * @return
	 */
	public static List<String> getFiles(String dir, boolean hasDir) {
		List<String> fileList = new ArrayList<String>();
		File root = new File(dir);
		if (root.isDirectory()) {
			File[] fileArray = root.listFiles();
			try {
				for (int i = 0; i < fileArray.length; i++) {
					// 如果是文件,添加到文件列表中
					if (fileArray[i].isFile()) {
						fileList.add(fileArray[i].getCanonicalPath());
					}
					// 否则递归遍历子目录
					else if (fileArray[i].isDirectory()) {
						if (hasDir) {
							log.debug("-------"  + fileArray[i].getCanonicalPath());
							fileList.add(fileArray[i].getCanonicalPath());
						}
						iterateFile(fileArray[i], fileList, hasDir);
					}
				}
			} catch (Exception e) {
				log.error("get files error.", e);
			}
		}
		return fileList;
	}
	
	/**
	 * 递归获取目录/文件下的文件路径
	 * @param file 当前文件
	 * @param fileList 存放文件路径的容器
	 * @param hasDir true:包含目录（文件+目录）     false:不包含目录（仅文件）
	 * @return
	 */
	private static void iterateFile(File file, List<String> fileList, boolean hasDir) throws IOException {
		File[] fileArray = file.listFiles();
		for (int i = 0; i < fileArray.length; i++) {
			// 如果是文件,添加到文件列表中
			if (fileArray[i].isFile()) {
				fileList.add(fileArray[i].getCanonicalPath());
				
			// 否则递归遍历子目录
			} else if (fileArray[i].isDirectory()) {
				if (hasDir) {
					log.debug("-+++++++--"  + fileArray[i].getCanonicalPath());
					fileList.add(fileArray[i].getCanonicalPath());
				}
				iterateFile(fileArray[i], fileList, hasDir);
			}
		}
	}

	/**
	 * 下载文件
	 * @param fileName 
	 * @param content 
	 * @param response
	 */
	public static void downloadFileByContent(String fileName,String content, HttpServletResponse response) {
		OutputStream toClient = null;
		try {
			InputStream fis = new BufferedInputStream(new ByteArrayInputStream(content.getBytes())); 
			byte[] buffer = new byte[fis.available()];
			fis.read(buffer);
			fis.close(); 
			// 清空response
			response.reset();
			// 设置response的Header
			response.addHeader("Content-Disposition", "attachment;filename="+fileName);
		//	response.addHeader("Content-Length", "" + file.length());
			toClient = new BufferedOutputStream(response.getOutputStream());
			response.setContentType("application/octet-stream");
			toClient.write(buffer);
			
		} catch (IOException ex) {
			ex.printStackTrace();
		}finally{
			try {
				if(toClient != null){
					toClient.flush();
					toClient.close();
				}			
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			
		}
	}

	/**
	 * 上传文件,用于保存临时文件
	 * @param request
	 * @param fileName 表单中的名称
	 */
	public static File uploadTempFile(HttpServletRequest request,String fileName){
		MultipartHttpServletRequest multipartRequest = (MultipartHttpServletRequest) request; 
		MultipartFile multipartFile = multipartRequest.getFile(fileName); 
		if(multipartFile != null){
			String originalFilename = multipartFile.getOriginalFilename();
			String ext = originalFilename.substring(originalFilename.lastIndexOf(".")+1,originalFilename.length());  
		    //对扩展名进行小写转换  
		    ext = ext.toLowerCase();  
			log.debug("logImageName============"+originalFilename);
			log.debug("ext==="+ext);
			if(originalFilename != null){
				String dateStr = DateUtil.getCurrDateStr();
				File saveFilePath = new File(GlobalUtils.getAppPath()+ File.separator + SystemConstant.TEMP_FILE_PATH +File.separator + dateStr);
				if(!saveFilePath.exists()){
					saveFilePath.mkdirs();
				}
				String saveFileName =  SystemConstant.TEMP_FILE_PATH + File.separator + dateStr + File.separator + IDFactoryUtil.getId()+"."+ext;  
				String newFileName = GlobalUtils.getAppPath()+  saveFileName;
				log.debug("newFileName======"+newFileName);
				File file = new File(newFileName); 
				try {     
		            multipartFile.transferTo(file);     
		        } catch (IllegalStateException e) {     
		            e.printStackTrace();     
		        } catch (IOException e) {            
		            e.printStackTrace();     
		        } 
		        return file;			
			}			
		}
		log.debug("文件上传失败");
		return null;	  
	}
	/**
	 * 上传文件
	 * @param request
	 * @param filePath 文件路径
	 * @param fileName 表单中的名称
	 */
	public static File uploadFile(HttpServletRequest request,String filePath,String fileName){
		MultipartHttpServletRequest multipartRequest = (MultipartHttpServletRequest) request; 
		MultipartFile multipartFile = multipartRequest.getFile(fileName); 
		if(multipartFile != null){
			String originalFilename = multipartFile.getOriginalFilename();
			String ext = originalFilename.substring(originalFilename.lastIndexOf(".")+1,originalFilename.length());  
		    //对扩展名进行小写转换  
		    ext = ext.toLowerCase();  
			log.debug("logImageName============"+originalFilename);
			log.debug("ext==="+ext);
			if(originalFilename != null){
				String dateStr = DateUtil.getCurrDateStr();
				File saveFilePath = new File(GlobalUtils.getAppPath()+ File.separator +filePath);
				if(!saveFilePath.exists()){
					saveFilePath.mkdirs();
				}
				String saveFileName = File.separator + filePath+IDFactoryUtil.getId()+"_"+fileName+"."+ext;  
				String newFileName = GlobalUtils.getAppPath()+  saveFileName;
				log.debug("newFileName======"+newFileName);
				File file = new File(newFileName); 
				try {     
		            multipartFile.transferTo(file);     
		        } catch (IllegalStateException e) {     
		            e.printStackTrace();     
		        } catch (IOException e) {            
		            e.printStackTrace();     
		        } 
		        return file;			
			}			
		}
		log.debug("文件上传失败");
		return null;	  
	}
	
	public static File uploadFile(MultipartFile uloadFile, String filePath, String fileName){
		InputStream is = null;
		OutputStream os = null;
		try {
			if(StringUtils.isBlank(filePath) || StringUtils.isBlank(fileName)){
				return null;
			}
			File file = new File(filePath);
			if(!file.exists()){
				file.mkdirs();
			}
			file = new File(filePath, fileName);
			is = uloadFile.getInputStream();
			os = new FileOutputStream(file);
			byte[] buf = new byte[1024];
			int len = 0;
			while ((len = is.read(buf)) != -1) {
				os.write(buf, 0, len);
				os.flush();
			}
			return file;
		} catch (Exception e) {
			e.printStackTrace();
		}finally{
			if(os != null){
				try {
					os.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			if(is != null){
				try {
					is.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
		return null;
	}
	
	
	
	public static void main(String args[]){
		//writeToTxt();
		String str = "dsds|qw|rr|r";
		String s[] = str.split("[|]");
		System.out.println(s[0]+"="+s[1]);
	}
	
	 public static void writeToTxt(){
	       
	        File file = new File("d:/dic_general.txt");
	        FileWriter fw = null;
	        BufferedWriter writer = null;
	        try {
	            fw = new FileWriter(file);
	            writer = new BufferedWriter(fw);
	           	for(int i = 1; i < 10000; i++){
	                writer.write("CUSTOM|XX20170426000"+i+"|20170426|102100099996|中国工商银行|102100000001|中国工商银行南京城西支行|62258320231323223|徐勃|"+Double.valueOf((Math.random()*100)).intValue()+"|1|0|清分|清算");
	                writer.newLine();//换行
	            }
	            writer.flush();
	        } catch (FileNotFoundException e) {
	            e.printStackTrace();
	        }catch (IOException e) {
	            e.printStackTrace();
	        }finally{
	            try {
	                writer.close();
	                fw.close();
	            } catch (IOException e) {
	                e.printStackTrace();
	            }
	        }
	    }
	  

}